1. Field of the Invention
Embodiments of the present invention generally relate to graphics programming and more specifically to integer-based functionality in a graphics shading language.
2. Description of the Related Art
Over the past decade, the cost of adding on-chip logic to processors has substantially decreased. Consequently, certain types of processors, such as advanced graphics processing units (GPUs), now include functionality not previously available in earlier GPU designs. For example, the newest GPUs are now able to perform full integer processing operations; whereas, such operations could not be effectively performed on the GPU. One benefit of this new capability is that more efficient graphics processing may now be performed on the GPU, thereby increasing overall performance in the graphics pipeline.
To fully realize additional processing capabilities of advanced GPUs, as much GPU functionality as possible needs to be exposed to graphics application developers. Among other things, doing so enables graphics application developers to tailor their shader programs to optimize the way GPUs process graphics scenes and images. Exposing new GPU processing capabilities, like full integer processing, to graphics application developers requires that the application programming interface (API) be configured with new calls and libraries that make new features and functionalities directly accessible by developers.
Some graphics APIs expose an interface to graphics application developers that consists of a set of calls written in a high-level programming language. To access specific capabilities of a target GPU, graphics application developers typically write shader programs for the target GPU in a high-level programming language such as the OpenGL shading language (GLSL). The shader programs are conveyed through the API to driver software that is configured to compile and assemble the shader programs into machine code programs. The machine code programs are then executed on the appropriate GPU processing units, as specified in the original shader program text.
As is well-known, floating-point values are useful in representing parameters related to graphics image data, such as light intensity or object depth, floating-point values are inappropriate in more general data processing that involve bit-wise operators or data structure indices. Integer values, however, are commonly used for processing bit-wise operators and computing data structure indices. Therefore, shader programs include constructs for storing and processing data in both integer and floating-point formats. One drawback of prior art APIs is that values that are encoded within the shader program using an integer format are not guaranteed to be processed using integer data types within a target GPU. In fact, integer variables within prior art APIs are typically converted to a floating-point format for processing within the GPU, precluding many integer related functions such as bitwise and pointer operators. For example, in OpenGL™ an integer value “2” used within a shader program is actually converted to a floating-point value “2.0” for processing within the GPU since integers are not supported as a native data type within the existing OpenGL™ API. The fact that OpenGL™ always casts values to a floating-point representation for processing within the GPU limits the applicability of OpenGL™ and GLSL to more general computational tasks desirable is more advanced graphics pipeline architectures. This API limitation thus restricts developers from taking advantage of native integer math support recently added to a new generation of GPUs.
As the foregoing illustrates, what is needed in the art is an application programming interface that exposes new processing capabilities of GPUs, such as the ability to perform native integer math operations, to graphics application developers.